import { Router } from 'express';
import { authenticateToken } from '../middleware/auth';
import { prisma } from '../lib/prisma';

const router = Router();

// 获取用户菜单（根据角色过滤）
router.get('/user-menu',
  authenticateToken,
  async (req, res) => {
    try {
      const userId = req.user?.id;
      if (!userId) {
        return res.status(401).json({ 
          code: 401, 
          message: '用户未认证' 
        });
      }

      // 获取用户信息
      const user = await prisma.user.findUnique({
        where: { id: userId },
        select: { role: true }
      });

      if (!user) {
        return res.status(404).json({ 
          code: 404, 
          message: '用户不存在' 
        });
      }

      // 获取该角色有权限查看的菜单
      const userMenus = await prisma.roleMenuPermission.findMany({
        where: { 
          role: user.role,
          canView: true 
        },
        include: {
          menu: {
            include: {
              children: true
            }
          }
        }
      });

      // 过滤和排序菜单数据
      const filteredUserMenus = userMenus
        .filter(item => item.menu.isActive)
        .map(item => ({
          ...item,
          menu: {
            ...item.menu,
            children: item.menu.children
              .filter(child => child.isActive)
              .sort((a, b) => a.sortOrder - b.sortOrder)
          }
        }))
        .sort((a, b) => a.menu.sortOrder - b.menu.sortOrder);

      // 过滤出主菜单（没有父级的菜单）
      const mainMenus = filteredUserMenus
        .filter(item => !item.menu.parentId)
        .map(item => ({
          key: item.menu.key,
          label: item.menu.label,
          icon: item.menu.icon,
          path: item.menu.path,
          canEdit: item.canEdit,
          canDelete: item.canDelete,
          children: item.menu.children
            .filter(child => {
              // 检查子菜单的权限
              const childPermission = filteredUserMenus.find(p => p.menuKey === child.key);
              return childPermission?.canView;
            })
            .map(child => {
              const childPermission = filteredUserMenus.find(p => p.menuKey === child.key);
              return {
                key: child.key,
                label: child.label,
                icon: child.icon,
                path: child.path,
                canEdit: childPermission?.canEdit || false,
                canDelete: childPermission?.canDelete || false
              };
            })
        }));

      res.json({
        code: 200,
        message: '获取用户菜单成功',
        data: {
          userRole: user.role,
          menus: mainMenus
        }
      });
    } catch (error) {
      console.error('获取用户菜单失败:', error);
      res.status(500).json({ 
        code: 500, 
        message: '获取用户菜单失败',
        error: error instanceof Error ? error.message : '未知错误'
      });
    }
  }
);

// 获取所有菜单配置（管理员专用）
router.get('/all',
  authenticateToken,
  async (req, res) => {
    try {
      const userId = req.user?.id;
      if (!userId) {
        return res.status(401).json({ 
          code: 401, 
          message: '用户未认证' 
        });
      }

      // 检查用户是否是管理员
      const user = await prisma.user.findUnique({
        where: { id: userId },
        select: { role: true }
      });

      if (user?.role !== 'ADMIN') {
        return res.status(403).json({ 
          code: 403, 
          message: '权限不足，只有管理员可以查看所有菜单配置' 
        });
      }

      // 获取所有菜单配置
      const allMenus = await prisma.menuConfig.findMany({
        include: {
          children: {
            orderBy: {
              sortOrder: 'asc'
            }
          }
        },
        orderBy: {
          sortOrder: 'asc'
        }
      });

      res.json({
        code: 200,
        message: '获取所有菜单配置成功',
        data: allMenus
      });
    } catch (error) {
      console.error('获取所有菜单配置失败:', error);
      res.status(500).json({ 
        code: 500, 
        message: '获取所有菜单配置失败',
        error: error instanceof Error ? error.message : '未知错误'
      });
    }
  }
);

// 获取角色权限配置（管理员专用）
router.get('/role-permissions',
  authenticateToken,
  async (req, res) => {
    try {
      const userId = req.user?.id;
      if (!userId) {
        return res.status(401).json({ 
          code: 401, 
          message: '用户未认证' 
        });
      }

      // 检查用户是否是管理员
      const user = await prisma.user.findUnique({
        where: { id: userId },
        select: { role: true }
      });

      if (user?.role !== 'ADMIN') {
        return res.status(403).json({ 
          code: 403, 
          message: '权限不足，只有管理员可以查看角色权限配置' 
        });
      }

      // 获取所有角色权限配置
      const rolePermissions = await prisma.roleMenuPermission.findMany({
        include: {
          menu: true
        },
        orderBy: [
          { role: 'asc' },
          { menuKey: 'asc' }
        ]
      });

      res.json({
        code: 200,
        message: '获取角色权限配置成功',
        data: rolePermissions
      });
    } catch (error) {
      console.error('获取角色权限配置失败:', error);
      res.status(500).json({ 
        code: 500, 
        message: '获取角色权限配置失败',
        error: error instanceof Error ? error.message : '未知错误'
      });
    }
  }
);

export default router;
